home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / util / gnu / patch_2_1.lha / patch-2.1patch.c < prev    next >
C/C++ Source or Header  |  1993-06-23  |  24KB  |  1,004 lines
  1. char rcsid[] =
  2.     "$Header: patch.c,v 2.0.2.0 90/05/01 22:17:50 davison Locked $";
  3.  
  4. /* patch - a program to apply diffs to original files
  5.  *
  6.  * Copyright 1986, Larry Wall
  7.  *
  8.  * This program may be copied as long as you don't try to make any
  9.  * money off of it, or pretend that you wrote it.
  10.  *
  11.  * $Log:    patch.c,v $
  12.  * Revision 2.0.2.0  90/05/01  22:17:50  davison
  13.  * patch12u: unidiff support added
  14.  * 
  15.  * Revision 2.0.1.6  88/06/22  20:46:39  lwall
  16.  * patch12: rindex() wasn't declared
  17.  * 
  18.  * Revision 2.0.1.5  88/06/03  15:09:37  lwall
  19.  * patch10: exit code improved.
  20.  * patch10: better support for non-flexfilenames.
  21.  * 
  22.  * Revision 2.0.1.4  87/02/16  14:00:04  lwall
  23.  * Short replacement caused spurious "Out of sync" message.
  24.  * 
  25.  * Revision 2.0.1.3  87/01/30  22:45:50  lwall
  26.  * Improved diagnostic on sync error.
  27.  * Moved do_ed_script() to pch.c.
  28.  * 
  29.  * Revision 2.0.1.2  86/11/21  09:39:15  lwall
  30.  * Fuzz factor caused offset of installed lines.
  31.  * 
  32.  * Revision 2.0.1.1  86/10/29  13:10:22  lwall
  33.  * Backwards search could terminate prematurely.
  34.  * 
  35.  * Revision 2.0  86/09/17  15:37:32  lwall
  36.  * Baseline for netwide release.
  37.  * 
  38.  * Revision 1.5  86/08/01  20:53:24  lwall
  39.  * Changed some %d's to %ld's.
  40.  * Linted.
  41.  * 
  42.  * Revision 1.4  86/08/01  19:17:29  lwall
  43.  * Fixes for machines that can't vararg.
  44.  * Added fuzz factor.
  45.  * Generalized -p.
  46.  * General cleanup.
  47.  * 
  48.  * 85/08/15 van%ucbmonet@berkeley
  49.  * Changes for 4.3bsd diff -c.
  50.  *
  51.  * Revision 1.3  85/03/26  15:07:43  lwall
  52.  * Frozen.
  53.  * 
  54.  * Revision 1.2.1.9  85/03/12  17:03:35  lwall
  55.  * Changed pfp->_file to fileno(pfp).
  56.  * 
  57.  * Revision 1.2.1.8  85/03/12  16:30:43  lwall
  58.  * Check i_ptr and i_womp to make sure they aren't null before freeing.
  59.  * Also allow ed output to be suppressed.
  60.  * 
  61.  * Revision 1.2.1.7  85/03/12  15:56:13  lwall
  62.  * Added -p option from jromine@uci-750a.
  63.  * 
  64.  * Revision 1.2.1.6  85/03/12  12:12:51  lwall
  65.  * Now checks for normalness of file to patch.
  66.  * 
  67.  * Revision 1.2.1.5  85/03/12  11:52:12  lwall
  68.  * Added -D (#ifdef) option from joe@fluke.
  69.  * 
  70.  * Revision 1.2.1.4  84/12/06  11:14:15  lwall
  71.  * Made smarter about SCCS subdirectories.
  72.  * 
  73.  * Revision 1.2.1.3  84/12/05  11:18:43  lwall
  74.  * Added -l switch to do loose string comparison.
  75.  * 
  76.  * Revision 1.2.1.2  84/12/04  09:47:13  lwall
  77.  * Failed hunk count not reset on multiple patch file.
  78.  * 
  79.  * Revision 1.2.1.1  84/12/04  09:42:37  lwall
  80.  * Branch for sdcrdcf changes.
  81.  * 
  82.  * Revision 1.2  84/11/29  13:29:51  lwall
  83.  * Linted.  Identifiers uniqified.  Fixed i_ptr malloc() bug.  Fixed
  84.  * multiple calls to mktemp().  Will now work on machines that can only
  85.  * read 32767 chars.  Added -R option for diffs with new and old swapped.
  86.  * Various cosmetic changes.
  87.  * 
  88.  * Revision 1.1  84/11/09  17:03:58  lwall
  89.  * Initial revision
  90.  * 
  91.  */
  92.  
  93. #ifdef AMIGA
  94. #include <dos.h>
  95. #include <proto/exec.h>
  96. #endif /* AMIGA */
  97. #include "INTERN.h"
  98. #include "common.h"
  99. #include "EXTERN.h"
  100. #include "version.h"
  101. #include "util.h"
  102. #include "pch.h"
  103. #include "inp.h"
  104. #include "backupfile.h"
  105. #include "getopt.h"
  106.  
  107. /* procedures */
  108.  
  109. void reinitialize_almost_everything();
  110. void get_some_switches();
  111. LINENUM locate_hunk();
  112. void abort_hunk();
  113. void apply_hunk();
  114. void init_output();
  115. void init_reject();
  116. void copy_till();
  117. void spew_output();
  118. void dump_line();
  119. bool patch_match();
  120. bool similar();
  121. void re_input();
  122. void my_exit();
  123. #ifdef AMIGA
  124. void amiga_exit();
  125. static char curpath[256];
  126. #endif /* AMIGA */
  127.  
  128. /* TRUE if -E was specified on command line.  */
  129. static int remove_empty_files = FALSE;
  130.  
  131. /* TRUE if -R was specified on command line.  */
  132. static int reverse_flag_specified = FALSE;
  133.  
  134. /* Apply a set of diffs as appropriate. */
  135.  
  136. int
  137. main(argc,argv)
  138. int argc;
  139. char **argv;
  140. {
  141.     LINENUM where;
  142.     LINENUM newwhere;
  143.     LINENUM fuzz;
  144.     LINENUM mymaxfuzz;
  145.     int hunk = 0;
  146.     int failed = 0;
  147.     int failtotal = 0;
  148.     bool rev_okayed = 0;
  149.     int i;
  150.  
  151. #ifdef AMIGA
  152.     if (!onexit (amiga_exit)) {
  153.       fputs ("Couldn't set exit trap.\n", stderr);
  154.       exit (20);
  155.     }
  156.     if (getcwd(curpath,256) == NULL) {
  157.       fputs ("Couldn't get current path.\n", stderr);
  158.       exit (20);
  159.     }
  160. #endif /* AMIGA */
  161.  
  162.     setbuf(stderr, serrbuf);
  163.     for (i = 0; i<MAXFILEC; i++)
  164.     filearg[i] = Nullch;
  165.  
  166. #ifndef AMIGA
  167.     myuid = getuid();
  168.  
  169.     /* Cons up the names of the temporary files.  */
  170.     {
  171.       /* Directory for temporary files.  */
  172.       char *tmpdir;
  173.       int tmpname_len;
  174.  
  175.       tmpdir = getenv ("TMPDIR");
  176.       if (tmpdir == NULL) {
  177.     tmpdir = "/tmp";
  178.       }
  179.       tmpname_len = strlen (tmpdir) + 20;
  180.  
  181.       TMPOUTNAME = (char *) malloc (tmpname_len);
  182.       strcpy (TMPOUTNAME, tmpdir);
  183.       strcat (TMPOUTNAME, "/patchoXXXXXX");
  184.       Mktemp(TMPOUTNAME);
  185.  
  186.       TMPINNAME = (char *) malloc (tmpname_len);
  187.       strcpy (TMPINNAME, tmpdir);
  188.       strcat (TMPINNAME, "/patchiXXXXXX");
  189.       Mktemp(TMPINNAME);
  190.  
  191.       TMPREJNAME = (char *) malloc (tmpname_len);
  192.       strcpy (TMPREJNAME, tmpdir);
  193.       strcat (TMPREJNAME, "/patchrXXXXXX");
  194.       Mktemp(TMPREJNAME);
  195.  
  196.       TMPPATNAME = (char *) malloc (tmpname_len);
  197.       strcpy (TMPPATNAME, tmpdir);
  198.       strcat (TMPPATNAME, "/patchpXXXXXX");
  199.       Mktemp(TMPPATNAME);
  200.     }
  201. #else /* AMIGA */
  202.     /* Cons up the names of the temporary files.  */
  203.     {
  204.       struct Task *Task;
  205.  
  206.       Task = FindTask (NULL);
  207.  
  208.       TMPOUTNAME = (char *) malloc (20);
  209.       sprintf (TMPOUTNAME, "T:patcho%08lx", Task);
  210.  
  211.       TMPINNAME = (char *) malloc (20);
  212.       sprintf (TMPINNAME, "T:patchi%08lx", Task);
  213.  
  214.       TMPREJNAME = (char *) malloc (20);
  215.       sprintf (TMPREJNAME, "T:patchr%08lx", Task);
  216.  
  217.       TMPPATNAME = (char *) malloc (20);
  218.       sprintf (TMPPATNAME, "T:patchp%08lx", Task);
  219.     }
  220. #endif /* AMIGA */
  221.  
  222.     {
  223.       char *v;
  224.  
  225.       v = getenv ("SIMPLE_BACKUP_SUFFIX");
  226.       if (v)
  227.     simple_backup_suffix = v;
  228.       else
  229.     simple_backup_suffix = ".orig";
  230. #ifndef NODIR
  231.       v = getenv ("VERSION_CONTROL");
  232.       backup_type = get_version (v); /* OK to pass NULL. */
  233. #endif
  234.     }
  235.  
  236.     /* parse switches */
  237.     Argc = argc;
  238.     Argv = argv;
  239.     get_some_switches();
  240.     
  241.     /* make sure we clean up /tmp in case of disaster */
  242.     set_signals(0);
  243.  
  244.     for (
  245.     open_patch_file(filearg[1]);
  246.     there_is_another_patch();
  247.     reinitialize_almost_everything()
  248.     ) {                    /* for each patch in patch file */
  249.  
  250.     if (outname == Nullch)
  251.         outname = savestr(filearg[0]);
  252.     
  253.     /* for ed script just up and do it and exit */
  254.     if (diff_type == ED_DIFF) {
  255.         do_ed_script();
  256.         continue;
  257.     }
  258.     
  259.     /* initialize the patched file */
  260.     if (!skip_rest_of_patch)
  261.         init_output(TMPOUTNAME);
  262.     
  263.     /* initialize reject file */
  264.     init_reject(TMPREJNAME);
  265.     
  266.     /* find out where all the lines are */
  267.     if (!skip_rest_of_patch)
  268.         scan_input(filearg[0]);
  269.     
  270.     /* from here on, open no standard i/o files, because malloc */
  271.     /* might misfire and we can't catch it easily */
  272.     
  273.     /* apply each hunk of patch */
  274.     hunk = 0;
  275.     failed = 0;
  276.     rev_okayed = FALSE;
  277.     out_of_mem = FALSE;
  278.     while (another_hunk()) {
  279.         hunk++;
  280.         fuzz = Nulline;
  281.         mymaxfuzz = pch_context();
  282.         if (maxfuzz < mymaxfuzz)
  283.         mymaxfuzz = maxfuzz;
  284.         if (!skip_rest_of_patch) {
  285.         do {
  286.             where = locate_hunk(fuzz);
  287.             if (hunk == 1 && where == Nulline && !(force|rev_okayed)) {
  288.                         /* dwim for reversed patch? */
  289.             if (!pch_swap()) {
  290.                 if (fuzz == Nulline)
  291.                 say1(
  292. "Not enough memory to try swapped hunk!  Assuming unswapped.\n");
  293.                 continue;
  294.             }
  295.             reverse = !reverse;
  296.             where = locate_hunk(fuzz);  /* try again */
  297.             if (where == Nulline) {        /* didn't find it swapped */
  298.                 if (!pch_swap())         /* put it back to normal */
  299.                 fatal1("lost hunk on alloc error!\n");
  300.                 reverse = !reverse;
  301.             }
  302.             else if (noreverse) {
  303.                 if (!pch_swap())         /* put it back to normal */
  304.                 fatal1("lost hunk on alloc error!\n");
  305.                 reverse = !reverse;
  306.                 say1(
  307. "Ignoring previously applied (or reversed) patch.\n");
  308.                 skip_rest_of_patch = TRUE;
  309.             }
  310.             else if (batch) {
  311.                 if (verbose)
  312.                 say3(
  313. "%seversed (or previously applied) patch detected!  %s -R.",
  314.                 reverse ? "R" : "Unr",
  315.                 reverse ? "Assuming" : "Ignoring");
  316.             }
  317.             else {
  318.                 ask3(
  319. "%seversed (or previously applied) patch detected!  %s -R? [y] ",
  320.                 reverse ? "R" : "Unr",
  321.                 reverse ? "Assume" : "Ignore");
  322.                 if (*buf == 'n') {
  323.                 ask1("Apply anyway? [n] ");
  324.                 if (*buf == 'y')
  325.                     rev_okayed = TRUE;
  326.                 else
  327.                     skip_rest_of_patch = TRUE;
  328.                 where = Nulline;
  329.                 reverse = !reverse;
  330.                 if (!pch_swap())  /* put it back to normal */
  331.                     fatal1("lost hunk on alloc error!\n");
  332.                 }
  333.             }
  334.             }
  335.         } while (!skip_rest_of_patch && where == Nulline &&
  336.             ++fuzz <= mymaxfuzz);
  337.  
  338.         if (skip_rest_of_patch) {        /* just got decided */
  339.             Fclose(ofp);
  340.             ofp = Nullfp;
  341.         }
  342.         }
  343.  
  344.         newwhere = pch_newfirst() + last_offset;
  345.         if (skip_rest_of_patch) {
  346.         abort_hunk();
  347.         failed++;
  348.         if (verbose)
  349.             say3("Hunk #%d ignored at %ld.\n", hunk, newwhere);
  350.         }
  351.         else if (where == Nulline) {
  352.         abort_hunk();
  353.         failed++;
  354.         if (verbose)
  355.             say3("Hunk #%d failed at %ld.\n", hunk, newwhere);
  356.         }
  357.         else {
  358.         apply_hunk(where);
  359.         if (verbose) {
  360.             say3("Hunk #%d succeeded at %ld", hunk, newwhere);
  361.             if (fuzz)
  362.             say2(" with fuzz %ld", fuzz);
  363.             if (last_offset)
  364.             say3(" (offset %ld line%s)",
  365.                 last_offset, last_offset==1L?"":"s");
  366.             say1(".\n");
  367.         }
  368.         }
  369.     }
  370.  
  371.     if (out_of_mem && using_plan_a) {
  372.         optind = optind_last;
  373.         say1("\n\nRan out of memory using Plan A--trying again...\n\n");
  374.         if (ofp)
  375.             Fclose(ofp);
  376.         ofp = Nullfp;
  377.         if (rejfp)
  378.             Fclose(rejfp);
  379.         rejfp = Nullfp;
  380.         continue;
  381.     }
  382.     
  383.     assert(hunk);
  384.     
  385.     /* finish spewing out the new file */
  386.     if (!skip_rest_of_patch)
  387.         spew_output();
  388.     
  389.     /* and put the output where desired */
  390.     ignore_signals();
  391.     if (!skip_rest_of_patch) {
  392.         struct stat statbuf;
  393.         char *realout = outname;
  394.  
  395.         if (move_file(TMPOUTNAME, outname) < 0) {
  396.         toutkeep = TRUE;
  397.         realout = TMPOUTNAME;
  398.         chmod(TMPOUTNAME, filemode);
  399.         }
  400.         else
  401.         chmod(outname, filemode);
  402.  
  403.         if (remove_empty_files && stat(realout, &statbuf) == 0
  404.         && statbuf.st_size == 0) {
  405.         if (verbose)
  406.             say2("Removing %s (empty after patching).\n", realout);
  407. #ifndef AMIGA
  408.             while (unlink(realout) >= 0) ; /* while is for Eunice.  */
  409. #else /* AMIGA */
  410.             Unlink(realout);
  411. #endif /* AMIGA */
  412.         }
  413.     }
  414.     Fclose(rejfp);
  415.     rejfp = Nullfp;
  416.     if (failed) {
  417.         failtotal += failed;
  418.         if (!*rejname) {
  419.         Strcpy(rejname, outname);
  420.         addext(rejname, ".rej", '#');
  421.         }
  422.         if (skip_rest_of_patch) {
  423.         say4("%d out of %d hunks ignored--saving rejects to %s\n",
  424.             failed, hunk, rejname);
  425.         }
  426.         else {
  427.         say4("%d out of %d hunks failed--saving rejects to %s\n",
  428.             failed, hunk, rejname);
  429.         }
  430.         if (move_file(TMPREJNAME, rejname) < 0)
  431.         trejkeep = TRUE;
  432.     }
  433.     set_signals(1);
  434.     }
  435.     my_exit(failtotal);
  436. }
  437.  
  438. /* Prepare to find the next patch to do in the patch file. */
  439.  
  440. void
  441. reinitialize_almost_everything()
  442. {
  443.     re_patch();
  444.     re_input();
  445.  
  446.     input_lines = 0;
  447.     last_frozen_line = 0;
  448.  
  449.     filec = 0;
  450.     if (filearg[0] != Nullch && !out_of_mem) {
  451.     free(filearg[0]);
  452.     filearg[0] = Nullch;
  453.     }
  454.  
  455.     if (outname != Nullch) {
  456.     free(outname);
  457.     outname = Nullch;
  458.     }
  459.  
  460.     last_offset = 0;
  461.  
  462.     diff_type = 0;
  463.  
  464.     if (revision != Nullch) {
  465.     free(revision);
  466.     revision = Nullch;
  467.     }
  468.  
  469.     reverse = reverse_flag_specified;
  470.     skip_rest_of_patch = FALSE;
  471.  
  472.     get_some_switches();
  473.  
  474.     if (filec >= 2)
  475.     fatal1("you may not change to a different patch file\n");
  476. }
  477.  
  478. static char *shortopts = "-b:B:cd:D:eEfF:lnNo:p::r:RsStuvV:x:";
  479. static struct option longopts[] =
  480. {
  481.   {"suffix", 1, NULL, 'b'},
  482.   {"prefix", 1, NULL, 'B'},
  483.   {"context", 0, NULL, 'c'},
  484.   {"directory", 1, NULL, 'd'},
  485.   {"ifdef", 1, NULL, 'D'},
  486.   {"ed", 0, NULL, 'e'},
  487.   {"remove-empty-files", 0, NULL, 'E'},
  488.   {"force", 0, NULL, 'f'},
  489.   {"fuzz", 1, NULL, 'F'},
  490.   {"ignore-whitespace", 0, NULL, 'l'},
  491.   {"normal", 0, NULL, 'n'},
  492.   {"forward", 0, NULL, 'N'},
  493.   {"output", 1, NULL, 'o'},
  494.   {"strip", 2, NULL, 'p'},
  495.   {"reject-file", 1, NULL, 'r'},
  496.   {"reverse", 0, NULL, 'R'},
  497.   {"quiet", 0, NULL, 's'},
  498.   {"silent", 0, NULL, 's'},
  499.   {"skip", 0, NULL, 'S'},
  500.   {"batch", 0, NULL, 't'},
  501.   {"unified", 0, NULL, 'u'},
  502.   {"version", 0, NULL, 'v'},
  503.   {"version-control", 1, NULL, 'V'},
  504.   {"debug", 1, NULL, 'x'},
  505.   {0, 0, 0, 0}
  506. };
  507.  
  508. /* Process switches and filenames up to next '+' or end of list. */
  509.  
  510. void
  511. get_some_switches()
  512. {
  513.     Reg1 int optc;
  514.  
  515.     rejname[0] = '\0';
  516.     optind_last = optind;
  517.     if (optind == Argc)
  518.     return;
  519.     while ((optc = getopt_long (Argc, Argv, shortopts, longopts, (int *) 0))
  520.        != -1) {
  521.     if (optc == 1) {
  522.         if (strEQ(optarg, "+"))
  523.         return;
  524.         if (filec == MAXFILEC)
  525.         fatal1("too many file arguments\n");
  526.         filearg[filec++] = savestr(optarg);
  527.     }
  528.     else {
  529.         switch (optc) {
  530.         case 'b':
  531.         simple_backup_suffix = savestr(optarg);
  532.         break;
  533.         case 'B':
  534.         origprae = savestr(optarg);
  535.         break;
  536.         case 'c':
  537.         diff_type = CONTEXT_DIFF;
  538.         break;
  539.         case 'd':
  540.         if (chdir(optarg) < 0)
  541.             pfatal2("can't cd to %s", optarg);
  542.         break;
  543.         case 'D':
  544.             do_defines = TRUE;
  545.         if (!isalpha(*optarg) && '_' != *optarg)
  546.             fatal1("argument to -D is not an identifier\n");
  547.         Sprintf(if_defined, "#ifdef %s\n", optarg);
  548.         Sprintf(not_defined, "#ifndef %s\n", optarg);
  549.         Sprintf(end_defined, "#endif /* %s */\n", optarg);
  550.         break;
  551.         case 'e':
  552.         diff_type = ED_DIFF;
  553.         break;
  554.         case 'E':
  555.         remove_empty_files = TRUE;
  556.         break;
  557.         case 'f':
  558.         force = TRUE;
  559.         break;
  560.         case 'F':
  561.         maxfuzz = atoi(optarg);
  562.         break;
  563.         case 'l':
  564.         canonicalize = TRUE;
  565.         break;
  566.         case 'n':
  567.         diff_type = NORMAL_DIFF;
  568.         break;
  569.         case 'N':
  570.         noreverse = TRUE;
  571.         break;
  572.         case 'o':
  573.         outname = savestr(optarg);
  574.         break;
  575.         case 'p':
  576.         if (optarg)
  577.             strippath = atoi(optarg);
  578.         else
  579.             strippath = 0;
  580.         break;
  581.         case 'r':
  582.         Strcpy(rejname, optarg);
  583.         break;
  584.         case 'R':
  585.         reverse = TRUE;
  586.         reverse_flag_specified = TRUE;
  587.         break;
  588.         case 's':
  589.         verbose = FALSE;
  590.         break;
  591.         case 'S':
  592.         skip_rest_of_patch = TRUE;
  593.         break;
  594.         case 't':
  595.         batch = TRUE;
  596.         break;
  597.         case 'u':
  598.         diff_type = UNI_DIFF;
  599.         break;
  600.         case 'v':
  601.         version();
  602.         break;
  603.         case 'V':
  604. #ifndef NODIR
  605.         backup_type = get_version (optarg);
  606. #endif
  607.         break;
  608. #ifdef DEBUGGING
  609.         case 'x':
  610.         debug = atoi(optarg);
  611.         break;
  612. #endif
  613.         default:
  614.         fprintf(stderr, "\
  615. Usage: %s [options] [origfile [patchfile]] [+ [options] [origfile]]...\n",
  616.             Argv[0]);
  617.         fprintf(stderr, "\
  618. Options:\n\
  619.        [-ceEflnNRsStuv] [-b backup-ext] [-B backup-prefix] [-d directory]\n\
  620.        [-D symbol] [-F max-fuzz] [-o out-file] [-p[strip-count]]\n\
  621.        [-r rej-name] [-V {numbered,existing,simple}] [--context]\n\
  622.        [--prefix=backup-prefix] [--suffix=backup-ext] [--ifdef=symbol]\n\
  623.        [--directory=directory] [--ed] [--fuzz=max-fuzz] [--force] [--batch]\n\
  624.        [--ignore-whitespace] [--forward] [--reverse] [--output=out-file]\n");
  625.         fprintf(stderr, "\
  626.        [--strip[=strip-count]] [--normal] [--reject-file=rej-name] [--skip]\n\
  627.        [--remove-empty-files] [--quiet] [--silent] [--unified] [--version]\n\
  628.        [--version-control={numbered,existing,simple}]\n");
  629.         my_exit(1);
  630.         }
  631.     }
  632.     }
  633.  
  634.     /* Process any filename args given after "--".  */
  635.     for (; optind < Argc; ++optind) {
  636.     if (filec == MAXFILEC)
  637.         fatal1("too many file arguments\n");
  638.     filearg[filec++] = savestr(Argv[optind]);
  639.     }
  640. }
  641.  
  642. /* Attempt to find the right place to apply this hunk of patch. */
  643.  
  644. LINENUM
  645. locate_hunk(fuzz)
  646. LINENUM fuzz;
  647. {
  648.     Reg1 LINENUM first_guess = pch_first() + last_offset;
  649.     Reg2 LINENUM offset;
  650.     LINENUM pat_lines = pch_ptrn_lines();
  651.     Reg3 LINENUM max_pos_offset = input_lines - first_guess
  652.                 - pat_lines + 1; 
  653.     Reg4 LINENUM max_neg_offset = first_guess - last_frozen_line - 1
  654.                 + pch_context();
  655.  
  656.     if (!pat_lines)            /* null range matches always */
  657.     return first_guess;
  658.     if (max_neg_offset >= first_guess)    /* do not try lines < 0 */
  659.     max_neg_offset = first_guess - 1;
  660.     if (first_guess <= input_lines && patch_match(first_guess, Nulline, fuzz))
  661.     return first_guess;
  662.     for (offset = 1; ; offset++) {
  663.     Reg5 bool check_after = (offset <= max_pos_offset);
  664.     Reg6 bool check_before = (offset <= max_neg_offset);
  665.  
  666.     if (check_after && patch_match(first_guess, offset, fuzz)) {
  667. #ifdef DEBUGGING
  668.         if (debug & 1)
  669.         say3("Offset changing from %ld to %ld\n", last_offset, offset);
  670. #endif
  671.         last_offset = offset;
  672.         return first_guess+offset;
  673.     }
  674.     else if (check_before && patch_match(first_guess, -offset, fuzz)) {
  675. #ifdef DEBUGGING
  676.         if (debug & 1)
  677.         say3("Offset changing from %ld to %ld\n", last_offset, -offset);
  678. #endif
  679.         last_offset = -offset;
  680.         return first_guess-offset;
  681.     }
  682.     else if (!check_before && !check_after)
  683.         return Nulline;
  684.     }
  685. }
  686.  
  687. /* We did not find the pattern, dump out the hunk so they can handle it. */
  688.  
  689. void
  690. abort_hunk()
  691. {
  692.     Reg1 LINENUM i;
  693.     Reg2 LINENUM pat_end = pch_end();
  694.     /* add in last_offset to guess the same as the previous successful hunk */
  695.     LINENUM oldfirst = pch_first() + last_offset;
  696.     LINENUM newfirst = pch_newfirst() + last_offset;
  697.     LINENUM oldlast = oldfirst + pch_ptrn_lines() - 1;
  698.     LINENUM newlast = newfirst + pch_repl_lines() - 1;
  699.     char *stars = (diff_type >= NEW_CONTEXT_DIFF ? " ****" : "");
  700.     char *minuses = (diff_type >= NEW_CONTEXT_DIFF ? " ----" : " -----");
  701.  
  702.     fprintf(rejfp, "***************\n");
  703.     for (i=0; i<=pat_end; i++) {
  704.     switch (pch_char(i)) {
  705.     case '*':
  706.         if (oldlast < oldfirst)
  707.         fprintf(rejfp, "*** 0%s\n", stars);
  708.         else if (oldlast == oldfirst)
  709.         fprintf(rejfp, "*** %ld%s\n", oldfirst, stars);
  710.         else
  711.         fprintf(rejfp, "*** %ld,%ld%s\n", oldfirst, oldlast, stars);
  712.         break;
  713.     case '=':
  714.         if (newlast < newfirst)
  715.         fprintf(rejfp, "--- 0%s\n", minuses);
  716.         else if (newlast == newfirst)
  717.         fprintf(rejfp, "--- %ld%s\n", newfirst, minuses);
  718.         else
  719.         fprintf(rejfp, "--- %ld,%ld%s\n", newfirst, newlast, minuses);
  720.         break;
  721.     case '\n':
  722.         fprintf(rejfp, "%s", pfetch(i));
  723.         break;
  724.     case ' ': case '-': case '+': case '!':
  725.         fprintf(rejfp, "%c %s", pch_char(i), pfetch(i));
  726.         break;
  727.     default:
  728.         fatal1("fatal internal error in abort_hunk\n"); 
  729.     }
  730.     }
  731. }
  732.  
  733. /* We found where to apply it (we hope), so do it. */
  734.  
  735. void
  736. apply_hunk(where)
  737. LINENUM where;
  738. {
  739.     Reg1 LINENUM old = 1;
  740.     Reg2 LINENUM lastline = pch_ptrn_lines();
  741.     Reg3 LINENUM new = lastline+1;
  742. #define OUTSIDE 0
  743. #define IN_IFNDEF 1
  744. #define IN_IFDEF 2
  745. #define IN_ELSE 3
  746.     Reg4 int def_state = OUTSIDE;
  747.     Reg5 bool R_do_defines = do_defines;
  748.     Reg6 LINENUM pat_end = pch_end();
  749.  
  750.     where--;
  751.     while (pch_char(new) == '=' || pch_char(new) == '\n')
  752.     new++;
  753.     
  754.     while (old <= lastline) {
  755.     if (pch_char(old) == '-') {
  756.         copy_till(where + old - 1);
  757.         if (R_do_defines) {
  758.         if (def_state == OUTSIDE) {
  759.             fputs(not_defined, ofp);
  760.             def_state = IN_IFNDEF;
  761.         }
  762.         else if (def_state == IN_IFDEF) {
  763.             fputs(else_defined, ofp);
  764.             def_state = IN_ELSE;
  765.         }
  766.         fputs(pfetch(old), ofp);
  767.         }
  768.         last_frozen_line++;
  769.         old++;
  770.     }
  771.     else if (new > pat_end) {
  772.         break;
  773.     }
  774.     else if (pch_char(new) == '+') {
  775.         copy_till(where + old - 1);
  776.         if (R_do_defines) {
  777.         if (def_state == IN_IFNDEF) {
  778.             fputs(else_defined, ofp);
  779.             def_state = IN_ELSE;
  780.         }
  781.         else if (def_state == OUTSIDE) {
  782.             fputs(if_defined, ofp);
  783.             def_state = IN_IFDEF;
  784.         }
  785.         }
  786.         fputs(pfetch(new), ofp);
  787.         new++;
  788.     }
  789.     else if (pch_char(new) != pch_char(old)) {
  790.         say3("Out-of-sync patch, lines %ld,%ld--mangled text or line numbers, maybe?\n",
  791.         pch_hunk_beg() + old,
  792.         pch_hunk_beg() + new);
  793. #ifdef DEBUGGING
  794.         say3("oldchar = '%c', newchar = '%c'\n",
  795.         pch_char(old), pch_char(new));
  796. #endif
  797.         my_exit(1);
  798.     }
  799.     else if (pch_char(new) == '!') {
  800.         copy_till(where + old - 1);
  801.         if (R_do_defines) {
  802.            fputs(not_defined, ofp);
  803.            def_state = IN_IFNDEF;
  804.         }
  805.         while (pch_char(old) == '!') {
  806.         if (R_do_defines) {
  807.             fputs(pfetch(old), ofp);
  808.         }
  809.         last_frozen_line++;
  810.         old++;
  811.         }
  812.         if (R_do_defines) {
  813.         fputs(else_defined, ofp);
  814.         def_state = IN_ELSE;
  815.         }
  816.         while (pch_char(new) == '!') {
  817.         fputs(pfetch(new), ofp);
  818.         new++;
  819.         }
  820.     }
  821.     else {
  822.         assert(pch_char(new) == ' ');
  823.         old++;
  824.         new++;
  825.         if (R_do_defines && def_state != OUTSIDE) {
  826.         fputs(end_defined, ofp);
  827.         def_state = OUTSIDE;
  828.         }
  829.     }
  830.     }
  831.     if (new <= pat_end && pch_char(new) == '+') {
  832.     copy_till(where + old - 1);
  833.     if (R_do_defines) {
  834.         if (def_state == OUTSIDE) {
  835.             fputs(if_defined, ofp);
  836.         def_state = IN_IFDEF;
  837.         }
  838.         else if (def_state == IN_IFNDEF) {
  839.         fputs(else_defined, ofp);
  840.         def_state = IN_ELSE;
  841.         }
  842.     }
  843.     while (new <= pat_end && pch_char(new) == '+') {
  844.         fputs(pfetch(new), ofp);
  845.         new++;
  846.     }
  847.     }
  848.     if (R_do_defines && def_state != OUTSIDE) {
  849.     fputs(end_defined, ofp);
  850.     }
  851. }
  852.  
  853. /* Open the new file. */
  854.  
  855. void
  856. init_output(name)
  857. char *name;
  858. {
  859.     ofp = fopen(name, "w");
  860.     if (ofp == Nullfp)
  861.     pfatal2("can't create %s", name);
  862. }
  863.  
  864. /* Open a file to put hunks we can't locate. */
  865.  
  866. void
  867. init_reject(name)
  868. char *name;
  869. {
  870.     rejfp = fopen(name, "w");
  871.     if (rejfp == Nullfp)
  872.     pfatal2("can't create %s", name);
  873. }
  874.  
  875. /* Copy input file to output, up to wherever hunk is to be applied. */
  876.  
  877. void
  878. copy_till(lastline)
  879. Reg1 LINENUM lastline;
  880. {
  881.     Reg2 LINENUM R_last_frozen_line = last_frozen_line;
  882.  
  883.     if (R_last_frozen_line > lastline)
  884.     fatal1("misordered hunks! output would be garbled\n");
  885.     while (R_last_frozen_line < lastline) {
  886.     dump_line(++R_last_frozen_line);
  887.     }
  888.     last_frozen_line = R_last_frozen_line;
  889. }
  890.  
  891. /* Finish copying the input file to the output file. */
  892.  
  893. void
  894. spew_output()
  895. {
  896. #ifdef DEBUGGING
  897.     if (debug & 256)
  898.     say3("il=%ld lfl=%ld\n",input_lines,last_frozen_line);
  899. #endif
  900.     if (input_lines)
  901.     copy_till(input_lines);        /* dump remainder of file */
  902.     Fclose(ofp);
  903.     ofp = Nullfp;
  904. }
  905.  
  906. /* Copy one line from input to output. */
  907.  
  908. void
  909. dump_line(line)
  910. LINENUM line;
  911. {
  912.     Reg1 char *s;
  913.     Reg2 char R_newline = '\n';
  914.  
  915.     /* Note: string is not null terminated. */
  916.     for (s=ifetch(line, 0); putc(*s, ofp) != R_newline; s++) ;
  917. }
  918.  
  919. /* Does the patch pattern match at line base+offset? */
  920.  
  921. bool
  922. patch_match(base, offset, fuzz)
  923. LINENUM base;
  924. LINENUM offset;
  925. LINENUM fuzz;
  926. {
  927.     Reg1 LINENUM pline = 1 + fuzz;
  928.     Reg2 LINENUM iline;
  929.     Reg3 LINENUM pat_lines = pch_ptrn_lines() - fuzz;
  930.  
  931.     for (iline=base+offset+fuzz; pline <= pat_lines; pline++,iline++) {
  932.     if (canonicalize) {
  933.         if (!similar(ifetch(iline, (offset >= 0)),
  934.              pfetch(pline),
  935.              pch_line_len(pline) ))
  936.         return FALSE;
  937.     }
  938.     else if (strnNE(ifetch(iline, (offset >= 0)),
  939.            pfetch(pline),
  940.            pch_line_len(pline) ))
  941.         return FALSE;
  942.     }
  943.     return TRUE;
  944. }
  945.  
  946. /* Do two lines match with canonicalized white space? */
  947.  
  948. bool
  949. similar(a,b,len)
  950. Reg1 char *a;
  951. Reg2 char *b;
  952. Reg3 int len;
  953. {
  954.     while (len) {
  955.     if (isspace(*b)) {        /* whitespace (or \n) to match? */
  956.         if (!isspace(*a))        /* no corresponding whitespace? */
  957.         return FALSE;
  958.         while (len && isspace(*b) && *b != '\n')
  959.         b++,len--;        /* skip pattern whitespace */
  960.         while (isspace(*a) && *a != '\n')
  961.         a++;            /* skip target whitespace */
  962.         if (*a == '\n' || *b == '\n')
  963.         return (*a == *b);    /* should end in sync */
  964.     }
  965.     else if (*a++ != *b++)        /* match non-whitespace chars */
  966.         return FALSE;
  967.     else
  968.         len--;            /* probably not necessary */
  969.     }
  970.     return TRUE;            /* actually, this is not reached */
  971.                     /* since there is always a \n */
  972. }
  973.  
  974. /* Exit with cleanup. */
  975.  
  976. void
  977. my_exit(status)
  978. int status;
  979. {
  980.     Unlink(TMPINNAME);
  981.     if (!toutkeep) {
  982.     Unlink(TMPOUTNAME);
  983.     }
  984.     if (!trejkeep) {
  985.     Unlink(TMPREJNAME);
  986.     }
  987.     Unlink(TMPPATNAME);
  988.     exit(status);
  989. }
  990.  
  991. void
  992. amiga_exit()
  993. {
  994.     unlink(TMPINNAME);
  995.     if (!toutkeep) {
  996.     Unlink(TMPOUTNAME);
  997.     }
  998.     if (!trejkeep) {
  999.     Unlink(TMPREJNAME);
  1000.     }
  1001.     Unlink(TMPPATNAME);
  1002.     chdir(curpath);
  1003. }
  1004.